% Het uiteindelijke resultaat van dit script is per belastingsknoop in het
% net een array met daarin per rij een pq-probleem. Elke rij bevat zes
% kolommen met in:
% Kolom 1: Lijn waarin het pq-probleem is opgetreden
% Kolom 2: Bus waarop het pq-probleem een invloed gehad heeft
% Kolom 3: Duur van het pq-probleem
% Kolom 4: Diepte van het pq-probleem (dips worden maar beschouwd indien de
%          spanning onder 90 procent van de nominale netspanning zakt)
% Kolom 5: Kans op voorkomen van het beschouwde pq-incident
% Kolom 6: Gewichtsfactor die dips waardeert tov van een kort onderbreking
% Kolom 7: Geeft met een cijfer aan over welk incident het gaat: 1=lijnfout ,2=busfout, 3=lijnen die wegvallen, 4=trafofouten 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
'&&&&&&&&&&&   Verzamelen van alle problemen afkomstig van lijnfouten   &&&&&&&&&&'
'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
gegevens;
if exist('lijnfout.mat','file') == 2
load lijnfout.mat;

aantal_dips
aantal_onderbrekingen
aantal_bussen

%Bedoeling van onderstaande lus is om de array dips_bussen_belasting te
%doorlopen en uit deze array per bus de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips
for j=1:1:aantal_bussen
    for i=1:1:aantal_dips
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if dips_bussen_belasting(i,2)==j
             %aanmaken van een string die zodat kan gekeken worden of voor deze bus reeds een array bestaat met daarin een dip 
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe dip toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de dip in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                %De kans op de dip afkomstig van een bepaalde lijnfout moet
                %opgeslagen worden in de vijfde kolom. De kans op het voorkomen 
                %van een bepaalde dip wordt berekend door de lengte van de lijn 
                %waarop de fout die de oorzaak is van de dip te vermenigvuldigen 
                %met de foutrate van luchtlijnen (in fouten/km.jaar). Eerst
                %worden de twee bussen opgezocht waartussen de lijn zich
                %bevindt. Dit wordt gedaan door de functie "bussen.m".
                %Vervolgens worden die twee bussen als input in de functie
                %"afstand.m" ingebracht. De afstand wordt dan vermenigvuldigd
                %en opgeslagen in de array
                [bus_1,bus_2]=bussen(dips_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*fout_rate_luchtlijnen; %foutrate door afstand maal foutrate van luchtlijnen te berekenen
                dips_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van dips in kolom 5
                %Bepalen wat de factor van de dip is gezien ten opzichte
                %van een korte onderbreking, deze factor wordt opgeslagen
                %in een variabele "dip_factor"
%                 if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                 else if dips_bussen_belasting(i,4) > 0.5
%                         dip_factor=0.4;
%                     else dip_factor=0.8;
%                     end
%                 end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                 lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                dips_bussen_belasting(i,7) = 1; %opslaan van het controlegetal voor lijnfouten
                C=[eval(test_string);dips_bussen_belasting(i,:)]; %onderaan bijvoegen van de dip aan de reeds bestaande array met problemen voor bus i
                eval([test_string '= C']);
             
             else
                [bus_1,bus_2]=bussen(dips_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*fout_rate_luchtlijnen; %foutrate door afstand maar foutrate van luchtlijnen te berekenen
                dips_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van dips in kolom 5
                %Bepalen wat de factor van de dip is gezien ten opzichte
                %van een korte onderbreking, deze factor wordt opgeslagen
                %in een variabele "dip_factor"
%                 if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                 else if dips_bussen_belasting(i,4) > 0.5
%                         dip_factor=0.4;
%                     else dip_factor=0.8;
%                     end
%                 end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                 lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                dips_bussen_belasting(i,7) = 1; %opslaan van het controlegetal voor lijnfouten
                nummer=num2str(j);
                v = strcat('problemen_bus_',nummer);
                eval([v ' = dips_bussen_belasting(i,:)']);
             end
        end
    end
end

%Bedoeling van onderstaande lus is om de array onderbreking_bussen_belasting te
%doorlopen en uit deze array per bussen de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips.

%Aanmaken van de random tijden van de onderbrekingen
tijden_onderbrekingen=tijden_lijn_fout(aantal_onderbrekingen);

for j=1:1:aantal_bussen
    for i=1:1:aantal_onderbrekingen
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if onderbreking_bussen_belasting(i,2)==j
             %aanmaken van een string die zodat kan gekeken worden of voor
             %deze bus reeds een array bestaat met daarin een onderbreking
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe onderbreking toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de onderbreking in deze variabele gekopieerd
             %worden.
             
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                %De kans op een onderbreking afkomstig van een bepaalde lijnfout moet
                %opgeslagen worden in de vijfde kolom. De kans op het voorkomen 
                %van een bepaalde onderbreking wordt berekend door de lengte van de lijn 
                %waarop de fout die de oorzaak is van de onderbreking te vermenigvuldigen 
                %met de foutrate van luchtlijnen (in fouten/km.jaar). Eerst
                %worden de twee bussen opgezocht waartussen de lijn zich
                %bevindt. Dit wordt gedaan door de functie "bussen.m".
                %Vervolgens worden die twee bussen als input in de functie
                %"afstand.m" ingebracht. De afstand wordt dan vermenigvuldigd
                %en opgeslagen in de array
                [bus_1,bus_2]=bussen(onderbreking_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*fout_rate_luchtlijnen; %foutrate door afstand maar foutrate van luchtlijnen te berekenen
                onderbreking_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van onderbrekingen in kolom 5
                onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                onderbreking_bussen_belasting(i,7) = 1; %opslaan van het controlegetal voor lijnfouten
                
                %random tijd kiezen (werd afgezet omdat het over een heel
                %klein aantal incidenten gaat en omdat het realistischer is
                %de tijd van die ondebreking te laten afhangen van de
                %schakeltijd van de schakelaar)
                %onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i);
                
                C=[eval(test_string);onderbreking_bussen_belasting(i,:)];
                eval([test_string '= C']);
             
             else
                [bus_1,bus_2]=bussen(onderbreking_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*fout_rate_luchtlijnen; %foutrate door afstand maar foutrate van luchtlijnen te berekenen
                onderbreking_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van onderbrekingen in kolom 5
                onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                onderbreking_bussen_belasting(i,7) = 1; %opslaan van het controlegetal voor lijnfouten
                
                %random tijd kiezen
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i);
                                
                nummer=num2str(j);
                v = strcat('problemen_bus_',nummer);
                eval([v ' = onderbreking_bussen_belasting(i,:)']);
             end
        end
    end
end
end
% Daarna worden alle problemen verzameld die afkomstig zijn van busfouten

'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
'&&&&&&&&&&&    Verzamelen van alle problemen afkomstig van busfouten    &&&&&&&&&'
'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
if exist('busfout.mat','file') == 2
load busfout.mat;

aantal_dips
aantal_onderbrekingen
aantal_bussen

%Bedoeling van onderstaande lus is om de array dips_bussen_belasting te
%doorlopen en uit deze array per bus de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips
for j=1:1:aantal_bussen
    for i=1:1:aantal_dips
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if dips_bussen_belasting(i,2)==j
            %aanmaken van een string die zodat kan gekeken worden of voor deze bus reeds een array bestaat met daarin een dip 
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe dip toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de dip in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                dips_bussen_belasting(i,5) = fout_rate_bussen; %foutrate opslaan in de array van dips in kolom 5
                %Bepalen wat de factor van de dip is gezien ten opzichte
                %van een korte onderbreking, deze factor wordt opgeslagen
                %in een variabele "dip_factor"
%                 if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                 else if dips_bussen_belasting(i,4) > 0.5
%                         dip_factor=0.4;
%                     else dip_factor=0.8;
%                     end
%                 end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                 lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                dips_bussen_belasting(i,7) = 2; %opslaan van het controlegetal voor busfouten
                C=[eval(test_string);dips_bussen_belasting(i,:)];
                eval([test_string '= C']);
             else
                 dips_bussen_belasting(i,5) = fout_rate_bussen; %foutrate opslaan in de array van dips in kolom 5
                %Bepalen wat de factor van de dip is gezien ten opzichte
                %van een korte onderbreking, deze factor wordt opgeslagen
                %in een variabele "dip_factor"
%                 if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                 else if dips_bussen_belasting(i,4) > 0.5
%                         dip_factor=0.4;
%                     else dip_factor=0.8;
%                     end
%                 end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                 lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                dips_bussen_belasting(i,7) = 2; %opslaan van het controlegetal voor busfouten
                 nummer=num2str(j);
                 v = strcat('problemen_bus_',nummer);
                 eval([v ' = dips_bussen_belasting(i,:)']);
             end
        end
    end
end

%Bedoeling van onderstaande lus is om de array onderbreking_bussen_belasting te
%doorlopen en uit deze array per bus de onderbrekingen die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips.

tijden_onderbrekingen=tijden_bus_fout(aantal_onderbrekingen);

for j=1:1:aantal_bussen
    for i=1:1:aantal_onderbrekingen
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if onderbreking_bussen_belasting(i,2)==j
            %aanmaken van een string die zodat kan gekeken worden of voor
            %deze bus reeds een array bestaat met daarin een onderbreking
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe onderbreking toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de onderbreking in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                 onderbreking_bussen_belasting(i,5) = fout_rate_bussen; %foutrate opslaan in de array van onderbrekingen in kolom 5
                 onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                 onderbreking_bussen_belasting(i,7) = 2; %opslaan van het controlegetal voor busfouten
                 C=[eval(test_string);onderbreking_bussen_belasting(i,:)];
                 eval([test_string '= C']);
                 %random tijd kiezen
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i);
                
             else
                 onderbreking_bussen_belasting(i,5) = fout_rate_bussen; %foutrate opslaan in de array van onderbrekingen in kolom 5
                 onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
%                  C=[eval(test_string);onderbreking_bussen_belasting(i,:)];
                 onderbreking_bussen_belasting(i,7) = 2; %opslaan van het controlegetal voor busfouten
%                  eval([test_string '= C']);
                 %random tijd kiezen
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i);
                
                 nummer=num2str(j);
                 v = strcat('problemen_bus_',nummer);
                 eval([v ' = onderbreking_bussen_belasting(i,:)']);
             end
        end
    end
end
end

% Daarna worden alle problemen verzameld die afkomstig zijn van lijnen die
% wegvallen

'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
'&&&&&&&&&&&    Verzamelen van alle problemen afkomstig van lijnen die wegvallen   &&&&&&&&&'
'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
if exist('lijn_uit.mat','file') == 2
load lijn_uit.mat;

aantal_dips
aantal_onderbrekingen
aantal_bussen

%Bedoeling van onderstaande lus is om de array dips_bussen_belasting te
%doorlopen en uit deze array per bussen de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips

%aanmaken van de tijden van de dips:
%tijden_dips=tijden_lijn_uitval(aantal_dips);

for j=1:1:aantal_bussen
    for i=1:1:aantal_dips
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if dips_bussen_belasting(i,2)==j
            %aanmaken van een string die zodat kan gekeken worden of voor deze bus reeds een array bestaat met daarin een dip 
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe dip toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de dip in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string) && isempty(eval(test_string))~=1
                %De kans op de dip afkomstig van een bepaalde lijn die wegvalt moet
                %opgeslagen worden in de vijfde kolom. De kans op het voorkomen 
                %van een bepaalde dip wordt berekend door de lengte van de lijn 
                %die wegvalt en die de oorzaak is van de dip te vermenigvuldigen 
                %met de uitval rate van luchtlijnen (in uitvallen/km.jaar). Eerst
                %worden de twee bussen opgezocht waartussen de lijn zich
                %bevindt. Dit wordt gedaan door de functie "bussen.m".
                %Vervolgens worden die twee bussen als input in de functie
                %"afstand.m" ingebracht. De afstand wordt dan vermenigvuldigd
                %en opgeslagen in de array
                [bus_1,bus_2]=bussen(dips_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*uitval_rate_luchtlijnen; %foutrate door afstand maar uitval rate van luchtlijnen te berekenen
                dips_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van dips in kolom 5
                
                %Bepalen wat de factor van de dip is gezien ten opzichte
                %van een korte onderbreking, deze factor wordt opgeslagen
                %in een variabele "dip_factor"
%                 if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                 else if dips_bussen_belasting(i,4) > 0.5
%                         dip_factor=0.4;
%                     else dip_factor=0.8;
%                     end
%                 end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                 lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                dips_bussen_belasting(i,7) = 3; %opslaan van het controlegetal voor lijnen die uitvallen
                %Slaan we nu de random tijden van de dips op in de array
                %van de dips:
                %dips_bussen_belasting(i,3) = tijden_dips(1,i); %Opslaan van de random tijd
                C=[eval(test_string);dips_bussen_belasting(i,:)];
                eval([test_string '= C']);
             
             else
                [bus_1,bus_2]=bussen(dips_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*uitval_rate_luchtlijnen; %foutrate door afstand maar uitval rate van luchtlijnen te berekenen
                dips_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van dips in kolom 5
                
                %Bepalen wat de factor van de dip is gezien ten opzichte
                %van een korte onderbreking, deze factor wordt opgeslagen
                %in een variabele "dip_factor"
%                 if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                 else if dips_bussen_belasting(i,4) > 0.5
%                         dip_factor=0.4;
%                     else dip_factor=0.8;
%                     end
%                 end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                 lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                dips_bussen_belasting(i,7) = 3; %opslaan van het controlegetal voor lijnen die uitvallen
                %Slaan we nu de random tijden van de dips op in de array
                %van de dips:
                %dips_bussen_belasting(i,3) = tijden_dips(1,i); %Opslaan van de random tijd
                nummer=num2str(j);
                v = strcat('problemen_bus_',nummer);
                eval([v ' = dips_bussen_belasting(i,:)']);
             end
        end
    end
end

%Bedoeling van onderstaande lus is om de array onderbreking_bussen_belasting te
%doorlopen en uit deze array per bussen de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips.

%Aanmaken van de random tijden van de onderbrekingen
tijden_onderbrekingen=tijden_lijn_uitval(aantal_onderbrekingen);

for j=1:1:aantal_bussen
    for i=1:1:aantal_onderbrekingen
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if onderbreking_bussen_belasting(i,2)==j
            %aanmaken van een string die zodat kan gekeken worden of voor
            %deze bus reeds een array bestaat met daarin een onderbreking
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe onderbreking toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de onderbreking in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                %De kans op een onderbreking afkomstig van een bepaalde lijn uitval moet
                %opgeslagen worden in de vijfde kolom. De kans op het voorkomen 
                %van een bepaalde onderbreking wordt berekend door de lengte van de lijn 
                %die uitvalt en die de oorzaak is van de onderbreking te vermenigvuldigen 
                %met de uitval rate van luchtlijnen (in uitvallen/km.jaar). Eerst
                %worden de twee bussen opgezocht waartussen de lijn zich
                %bevindt. Dit wordt gedaan door de functie "bussen.m".
                %Vervolgens worden die twee bussen als input in de functie
                %"afstand.m" ingebracht. De afstand wordt dan vermenigvuldigd
                %en opgeslagen in de array
                [bus_1,bus_2]=bussen(onderbreking_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*uitval_rate_luchtlijnen; %foutrate door afstand maal uitval rate van luchtlijnen te berekenen
                onderbreking_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van onderbrekingen in kolom 5
                %Slaan we nu de random tijden van de onderbrekingen op in de array
                %van de onderbrekingen:
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i); %Opslaan van de random tijd
                onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                onderbreking_bussen_belasting(i,7) = 3; %opslaan van het controlegetal voor lijnen die uitvallen
                C=[eval(test_string);onderbreking_bussen_belasting(i,:)];
                
                
                eval([test_string '= C']);
              else
                [bus_1,bus_2]=bussen(onderbreking_bussen_belasting(i,1));
                lengte_lijn=afstand(bus_1,bus_2); %berekenen afstand door bussen aan "afstand.m" aan te leveren
                foutrate=lengte_lijn*uitval_rate_luchtlijnen; %foutrate door afstand maal uitval rate van luchtlijnen te berekenen
                onderbreking_bussen_belasting(i,5) = foutrate; %foutrate opslaan in de array van onderbrekingen in kolom 5
                %Slaan we nu de random tijden van de onderbrekingen op in de array
                %van de onderbrekingen:
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i); %Opslaan van de random tijd
                onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                onderbreking_bussen_belasting(i,7) = 3; %opslaan van het controlegetal voor lijnen die uitvallen
                nummer=num2str(j);
                v = strcat('problemen_bus_',nummer);
                eval([v ' = onderbreking_bussen_belasting(i,:)']);
             end
        end
    end
end
end
%Daarna worden alle problemen verzameld die afkomstig zijn van trafofouten



'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
'&&&&&&&&&&&   Verzamelen van alle problemen afkomstig van trafofouten   &&&&&&&&&'
'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'
if exist('trafofout.mat','file') == 2
load trafofout.mat;

aantal_dips
aantal_onderbrekingen
aantal_bussen

%Bedoeling van onderstaande lus is om de array dips_bussen_belasting te
%doorlopen en uit deze array per bussen de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips

%aanmaken van de tijden van de dips:
%tijden_dips=tijden_trafo_fout(aantal_dips);

for j=1:1:aantal_bussen
    for i=1:1:aantal_dips
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if dips_bussen_belasting(i,2)==j
            %aanmaken van een string die zodat kan gekeken worden of voor deze bus reeds een array bestaat met daarin een dip 
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe dip toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de dip in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                 dips_bussen_belasting(i,5) = uitval_rate_trafo; %uitval rate trafo opslaan in de array van dips in kolom 5
                 %Slaan we nu de random tijden van de dips op in de array
                 %van de dips:
                 %dips_bussen_belasting(i,3) = tijden_dips(1,i); %Opslaan van de random tijd                 
                 %Bepalen wat de factor van de dip is gezien ten opzichte
                 %van een korte onderbreking, deze factor wordt opgeslagen
                 %in een variabele "dip_factor"
%                  if dips_bussen_belasting(i,4) > 0.7
%                      dip_factor=0.1;
%                  else if dips_bussen_belasting(i,4) > 0.5
%                          dip_factor=0.4;
%                       else dip_factor=0.8;
%                       end
%                  end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                  lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                 dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                 dips_bussen_belasting(i,7) = 4; %opslaan van het controlegetal voor trafofouten
                 C=[eval(test_string);dips_bussen_belasting(i,:)];
                 eval([test_string '= C']);
             else
                 dips_bussen_belasting(i,5) = uitval_rate_trafo; %uitval rate trafo opslaan in de array van dips in kolom 5
                 %Slaan we nu de random tijden van de dips op in de array
                 %van de dips:
                 %dips_bussen_belasting(i,3) = tijden_dips(1,i); %Opslaan van de random tijd
                 %Bepalen wat de factor van de dip is gezien ten opzichte
                 %van een korte onderbreking, deze factor wordt opgeslagen
                 %in een variabele "dip_factor"
%                  if dips_bussen_belasting(i,4) > 0.7
%                     dip_factor=0.1;
%                  else if dips_bussen_belasting(i,4) > 0.5
%                          dip_factor=0.4;
%                       else dip_factor=0.8;
%                       end
%                  end
                dip_factor = bepaal_dip_factor(dips_bussen_belasting(i,4));
%                  lengte_factor = dips_bussen_belasting(i,3)/0.3;
%                 dip_factor = dip_factor*lengte_factor;
%                 if dip_factor >= 1
%                     dip_factor =0.99;
%                 end
                 dips_bussen_belasting(i,6) = dip_factor; %opslaan van de dip factor tov een onderbreking in de array van dips in kolom 6
                 dips_bussen_belasting(i,7) = 4; %opslaan van het controlegetal voor trafofouten
                 nummer=num2str(j);
                 v = strcat('problemen_bus_',nummer);
                 eval([v ' = dips_bussen_belasting(i,:)']);
             end
        end
    end
end

%Bedoeling van onderstaande lus is om de array onderbreking_bussen_belasting te
%doorlopen en uit deze array per bussen de dips die voorkomen op deze bus
%te verzamelen. De buitenste lus doorloopt alle bussen, de binnenste lus
%loopt over alle dips.

%Aanmaken van de random tijden van de onderbrekingen
tijden_onderbrekingen=tijden_trafo_fout(aantal_onderbrekingen);

for j=1:1:aantal_bussen
    for i=1:1:aantal_onderbrekingen
        %testen of er een dip voorkomt in dips_bussen_belasting op bus j 
        if onderbreking_bussen_belasting(i,2)==j
            %aanmaken van een string die zodat kan gekeken worden of voor
            %deze bus reeds een array bestaat met daarin een onderbreking
             nummer_string = int2str(j);
             test_string=strcat('problemen_bus_',nummer_string);
             %kijken of de variabele reeds bestaat met de naam
             %problemen_bus_j. Als de variabele al bestaat dan moet de
             %nieuwe onderbreking toegevoegd worden aan de variabele, bestaat de
             %variabele nog niet dan moet er een nieuwe variabele
             %aangemaakt worden en moet de onderbreking in deze variabele gekopieerd
             %worden.
             if 1==exist(test_string)&& isempty(eval(test_string))~=1
                onderbreking_bussen_belasting(i,5) = uitval_rate_trafo; %uitval rate  trafo opslaan in de array van onderbrekingen in kolom 5
                %Slaan we nu de random tijden van de onderbrekingen op in de array
                %van de onderbrekingen:
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i); %Opslaan van de random tijd
                onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                onderbreking_bussen_belasting(i,7) = 4; %opslaan van het controlegetal voor trafofouten
                C=[eval(test_string);onderbreking_bussen_belasting(i,:)];
                eval([test_string '= C']);
             else
                onderbreking_bussen_belasting(i,5) = uitval_rate_trafo; %uitval rate  trafo opslaan in de array van onderbrekingen in kolom 5
                %Slaan we nu de random tijden van de onderbrekingen op in de array
                %van de onderbrekingen:
                onderbreking_bussen_belasting(i,3) = tijden_onderbrekingen(1,i); %Opslaan van de random tijd
                onderbreking_bussen_belasting(i,6) = 1; %opslaan van de dip factor tov een onderbreking in de array van onderbrekingen in kolom 6
                onderbreking_bussen_belasting(i,7) = 4; %opslaan van het controlegetal voor trafofouten
                nummer=num2str(j);
                v = strcat('problemen_bus_',nummer);
                eval([v ' = onderbreking_bussen_belasting(i,:)']);
             end
        end
    end
end
end


save problemen;
        
